const axios = require('axios');
const fs = require('fs-extra');
const path = require('path');
const FormData = require('form-data');

// 基础URL配置
const BASE_URL = 'http://localhost:3000/api';
const AUTH_URL = `${BASE_URL}/auth`;
const PUBLIC_MODEL_URL = `${BASE_URL}/public-models`;

// 测试用户凭据
const TEST_USER = {
    username: 'admin',
    password: '123456',
    email: '525675049@qq.com'
};

// 全局变量
let accessToken = '';
let testModelId = '';

// 测试文件路径
const TEST_MODEL_PATH = 'C:\\Users\\52567\\Desktop\\2492_open3dmodel\\House01\\House01.obj';

// 控制台日志颜色
const colors = {
    reset: '\x1b[0m',
    green: '\x1b[32m',
    red: '\x1b[31m',
    yellow: '\x1b[33m',
    blue: '\x1b[34m',
    magenta: '\x1b[35m'
};

/**
 * 格式化日志输出
 */
function logSection(title) {
    console.log(`\n${colors.magenta}===== ${title} =====${colors.reset}`);
}

function logSuccess(message) {
    console.log(`${colors.green}✅ ${message}${colors.reset}`);
}

function logError(message, error) {
    console.log(`${colors.red}❌ ${message}${colors.reset}`);
    if (error.response) {
        console.log(`状态码: ${error.response.status}`);
        console.log(`错误信息:`, error.response.data);
    } else if (error.request) {
        console.log('无法连接到服务器，请确保服务器正在运行');
    } else {
        console.log(`请求错误: ${error.message}`);
    }
}

function logInfo(message) {
    console.log(`${colors.blue}ℹ️ ${message}${colors.reset}`);
}

/**
 * 检查测试模型文件是否存在
 */
async function checkTestModelFile() {
    logSection('检查测试模型文件');

    try {
        if (await fs.pathExists(TEST_MODEL_PATH)) {
            logSuccess(`测试模型文件存在: ${TEST_MODEL_PATH}`);
            return true;
        } else {
            logError(`测试模型文件不存在: ${TEST_MODEL_PATH}`);
            return false;
        }
    } catch (error) {
        logError('检查测试模型文件失败', error);
        return false;
    }
}

/**
 * 注册测试用户
 */
async function registerTestUser() {
    logSection('注册测试用户');

    try {
        await axios.post(`${AUTH_URL}/register`, TEST_USER);
        logSuccess(`用户 "${TEST_USER.username}" 注册成功`);
        return true;
    } catch (error) {
        if (error.response && error.response.status === 409) {
            logInfo(`用户 "${TEST_USER.username}" 已存在，继续测试`);
            return true;
        }
        logError('注册测试用户失败', error);
        return false;
    }
}

/**
 * 登录测试用户
 */
async function loginTestUser() {
    logSection('登录测试用户');

    try {
        const response = await axios.post(`${AUTH_URL}/login`, {
            username: TEST_USER.username,
            password: TEST_USER.password
        });

        accessToken = response.data.data.token;
        logSuccess(`用户 "${TEST_USER.username}" 登录成功`);
        logInfo(`访问令牌: ${accessToken.substring(0, 15)}...`);
        return true;
    } catch (error) {
        logError('登录测试用户失败', error);
        return false;
    }
}

/**
 * 上传公共模型
 */
async function uploadPublicModel() {
    logSection('上传公共模型');

    try {
        // 创建表单数据
        const formData = new FormData();
        formData.append('file', fs.createReadStream(TEST_MODEL_PATH));

        // 发送上传请求
        const response = await axios.post(`${PUBLIC_MODEL_URL}/upload`, formData, {
            headers: {
                ...formData.getHeaders(),
                'Authorization': `Bearer ${accessToken}`
            }
        });

        testModelId = response.data.data.model.id;
        logSuccess('公共模型上传成功');
        logInfo(`模型ID: ${testModelId}`);
        logInfo(`模型名称: ${response.data.data.model.name}`);
        logInfo(`文件类型: ${response.data.data.model.fileType}`);
        return true;
    } catch (error) {
        logError('上传公共模型失败', error);
        return false;
    }
}

/**
 * 获取公共模型详情
 */
async function getPublicModelDetails() {
    logSection('获取公共模型详情');

    try {
        const response = await axios.get(`${PUBLIC_MODEL_URL}/${testModelId}`, {
            headers: {
                'Authorization': `Bearer ${accessToken}`
            }
        });

        logSuccess('获取公共模型详情成功');
        logInfo(`模型名称: ${response.data.data.name}`);
        logInfo(`文件类型: ${response.data.data.file.fileType}`);
        logInfo(`文件大小: ${response.data.data.file.fileSize} 字节`);
        return true;
    } catch (error) {
        logError('获取公共模型详情失败', error);
        return false;
    }
}

/**
 * 清理测试数据
 */
async function cleanupTestData() {
    logSection('清理测试数据');
    logInfo('注意: 此测试不会删除上传的模型，需要手动清理数据库');
    return true;
}

/**
 * 运行测试
 */
async function runTests() {
    console.log(`${colors.yellow}开始公共模型上传测试${colors.reset}`);
    
    // 检查测试文件
    if (!await checkTestModelFile()) {
        return;
    }

    // 注册并登录测试用户
    if (!await registerTestUser() || !await loginTestUser()) {
        return;
    }

    // 执行上传测试
    if (!await uploadPublicModel()) {
        return;
    }

    // 获取模型详情
    if (!await getPublicModelDetails()) {
        return;
    }

    // 清理测试数据
    await cleanupTestData();

    console.log(`\n${colors.green}公共模型上传测试完成${colors.reset}`);
}

// 执行测试
runTests().catch(error => {
    console.error(`${colors.red}测试过程中发生未捕获的错误:${colors.reset}`, error);
});